%matplotlib inline
import matplotlib.pyplot as plt

# Set the style for the entire notebook using a magic command
#plt.style.use('dark_background')

import pandas as pd

x = pd.read_csv('kaggleRussellySUI.csv')

x.head(3).style.set_properties(**{'background-color': 'white',                                                   
                                    'color': 'blue','font-size':'10px',                       
                                    'border-color': 'white'})

x = x.loc[x['country']=='United States']

x.head(3)

x.columns

#x.to_csv('kaggle_united_states_suicides.csv')

y = x[['country','year','suicides/100k pop']]

y.head()

averages_by_year = y.groupby('year')['suicides/100k pop'].mean()

#print(averages_by_year)

## Prepare for Seasonal Decomposition 

y.index

y.columns

z = averages_by_year


# Create a new DataFrame to store the averages
averages_df = pd.DataFrame({'Average Suicides/100k pop': averages_by_year.values},
                           index=pd.to_datetime(averages_by_year.index, format='%Y'))

# Set the frequency to yearly
averages_df.index.freq = 'YS'

#print(averages_df)
#print(averages_df.index)



z.to_csv('KEPP_SUI_DATA.csv')

#sui_d=pd.read_csv('KEEP-_SUI_DATA.csv')

y.head(5).style.set_properties(**{'background-color': 'white',                                                   
                                    'color': 'blue','font-size':'10px',                       
                                    'border-color': 'white'})

import pandas as pd

# Create your DataFrame (replace this with your actual DataFrame)
data = {'Column1': [1, 2, 3, 4, 5],
        'Column2': [6, 7, 8, 9, 10]}
df = pd.DataFrame(data)


# Style the DataFrame
styled_df = df.head(5).style.set_properties(**{
    'background-color': 'white',
    'color': 'blue',
    'font-size': '10px',
    'border-color': 'white'
})

print(df.head())
# Adjust the table width
styled_df = styled_df.set_table_styles([
    {'selector': 'table', 'props': [('max-width', '200px')]}  # Adjust the width as needed
])

# Display the styled DataFrame
styled_df

#print(styled_df.head())

type(styled_df)

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import seasonal_decompose



# Create a new DataFrame to store the averages
z = pd.DataFrame({'Average Suicides/100k pop': averages_by_year.values},
                 index=pd.to_datetime(averages_by_year.index, format='%Y'))

# Set the frequency to yearly
z.index.freq = 'YS'

# Apply seasonal decomposition
result = seasonal_decompose(z['Average Suicides/100k pop'], model='multiplicative')

# Plot the decomposition
plt.figure(figsize=(10, 6))
result.plot()
plt.show()

# Training and Performance 

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from sklearn.model_selection import TimeSeriesSplit


# Create a new DataFrame to store the averages
z = pd.DataFrame({'Average Suicides/100k pop': averages_by_year.values},
                 index=pd.to_datetime(averages_by_year.index, format='%Y'))

# Set the frequency to yearly
z.index.freq = 'YS'

# Split the data into training and testing sets
train_size = int(len(z) * 0.8)  # 80% for training
train, test = z[:train_size], z[train_size:]

# Apply Holt-Winters method on the training data
model = ExponentialSmoothing(train['Average Suicides/100k pop'], trend='add', seasonal='add', seasonal_periods=12)
result = model.fit()

# Forecast for the testing period
forecast = result.forecast(steps=len(test))

# Plot the original training data, testing data, and the forecast
plt.figure(figsize=(8, 4))
plt.plot(train.index, train['Average Suicides/100k pop'], label='Training Data')
plt.plot(test.index, test['Average Suicides/100k pop'], label='Testing Data', color='orange')
plt.plot(test.index, forecast, label='Forecast', color='red')
plt.legend()
plt.show()


# Save the plot as an image (PNG)
plt.savefig("sample_plot.png", format="png")

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.holtwinters import ExponentialSmoothing


# Apply Holt-Winters method
model = ExponentialSmoothing(z['Average Suicides/100k pop'], trend='add', seasonal='add', seasonal_periods=12)
result = model.fit()

# Forecast for the next 5 years
forecast = result.forecast(steps=5)

# Regressions    

# Plot the original data and the forecast
plt.figure(figsize=(6, 4))
plt.plot(z.index, z['Average Suicides/100k pop'], label='Original Data')
plt.plot(forecast.index, forecast, label='Forecast', color='red')
plt.legend()
plt.show()

z.head()

import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt

# Assuming your DataFrame "z" is already defined
# z = ...

# Create a copy of the DataFrame for regression
z_for_regression = z.copy()

# Reset the index for regression
z_reset = z_for_regression.reset_index()

# Calculate numerical years since the minimum year
z_reset['numerical_year'] = (z_reset['year'] - z_reset['year'].min()) / pd.Timedelta(days=365.25)

# Prepare the features (X) and target variable (y)
X = z_reset[['numerical_year']]
y = z_reset['Average Suicides/100k pop']

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Initialize and fit the linear regression model on the training data
model = LinearRegression()
model.fit(X_train, y_train)

# Make predictions using the model on the testing data
y_pred = model.predict(X_test)

# Calculate Mean Squared Error (MSE) as a measure of model performance
mse = mean_squared_error(y_test, y_pred)

# Visualize the data and regression line
plt.figure(figsize=(6, 4))
plt.scatter(z_reset['year'], z_reset['Average Suicides/100k pop'], label='Actual Data')
plt.plot(z_reset['year'], model.predict(X), color='red', label='Regression Line')  # Use model.predict(X) here
plt.xlabel('Year')
plt.ylabel('Average Suicides/100k pop')
plt.title('Regression Analysis: Average Suicides Over Time')
plt.legend()
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Print the regression coefficients
print("Intercept:", model.intercept_)
print("Coefficient:", model.coef_[0])

# Print the Mean Squared Error
print("Mean Squared Error:", mse)

!open .

!jupyter nbconvert --to html --template pj Suicide\ Yearly\ Data\ United\ States.ipynb